package cc.magicjson.synthesis.chain;


import cc.magicjson.synthesis.context.DiscountContext;

/**
 * 折扣检查器接口，责任链中的处理器接口
 */
public abstract class DiscountChecker {
    private DiscountChecker previous;  // 前一个处理器
    private DiscountChecker next;      // 下一个处理器

    /**
     * 设置下一个处理器
     * @param discountChecker 下一个折扣检查器
     * @return 返回下一个处理器，便于链式调用
     */
    public DiscountChecker next(DiscountChecker discountChecker) {
        DiscountChecker orderChecker = this;
        while (orderChecker.next != null) {
            orderChecker = orderChecker.next;
        }
        orderChecker.next = discountChecker;
        discountChecker.previous = orderChecker;
        return this;
    }

    /**
     * 处理折扣计算请求
     * @param context 折扣计算上下文
     * @return 处理后的上下文
     */
    public DiscountContext process(DiscountContext context) {
        // 执行当前处理器的检查
        boolean shouldContinue = doCheck(context);

        // 如果需要继续且存在下一个处理器，则继续传递
        if (shouldContinue && next != null) {
            return next.process(context);
        }
        return context;
    }

    /**
     * 执行具体的检查逻辑，由子类实现
     * @param context 折扣计算上下文
     * @return 是否继续执行责任链
     */
    protected abstract boolean doCheck(DiscountContext context);

    /**
     * 回滚操作，当需要取消计算结果时使用
     * @param context 折扣计算上下文
     */
    public void rollback(DiscountContext context) {
        // 执行当前处理器的回滚
        doRollback(context);

        // 如果存在上一个处理器，则继续向上回滚
        if (previous != null) {
            previous.rollback(context);
        }
    }

    /**
     * 执行具体的回滚逻辑，由子类实现
     * @param context 折扣计算上下文
     */
    protected abstract void doRollback(DiscountContext context);
}
